home *** CD-ROM | disk | FTP | other *** search
/ Amiga Format CD 34 / Amiga Format CD34 (1998-11-20)(Future Publishing)(GB)[!][Christmas issue].iso / -seriously_amiga- / programming / c / mesa-2.6 / src / mesamain.c < prev    next >
C/C++ Source or Header  |  1998-10-01  |  9KB  |  370 lines
  1. /*
  2.  * AmigaMesaRTL graphics library
  3.  * Version:  2.0
  4.  * Copyright (C) 1998  Jarno van der Linden
  5.  *
  6.  * This library is free software; you can redistribute it and/or
  7.  * modify it under the terms of the GNU Library General Public
  8.  * License as published by the Free Software Foundation; either
  9.  * version 2 of the License, or (at your option) any later version.
  10.  *
  11.  * This library is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14.  * Library General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU Library General Public
  17.  * License along with this library; if not, write to the Free
  18.  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19.  */
  20.  
  21. /*
  22.  * mesamain.c
  23.  *
  24.  * Version 2.0  13 Sep 1998
  25.  * by Jarno van der Linden
  26.  * jarno@kcbbs.gen.nz
  27.  *
  28.  * Driver interface to some Mesa setup stuff
  29.  * (Basically, context.h interface)
  30.  * - Added automagic mesamain.library opening
  31.  *
  32.  */
  33.  
  34. #include <dos.h>
  35. #include <constructor.h>
  36.  
  37. #include <proto/exec.h>
  38. #include <proto/dos.h>
  39. #include <proto/utility.h>
  40.  
  41. #include <stdlib.h>
  42. #include <string.h>
  43.  
  44. #include "gl/gl.h"
  45. #include "gl/mesamain.h"
  46. #include "gl/mesadriver.h"
  47.  
  48. #include "context.h"
  49. #include "matrix.h"
  50.  
  51.  
  52. struct Library *mesadriverBase = NULL;
  53. static BOOL havedriver = FALSE;
  54. static BOOL mydriver = FALSE;
  55.  
  56.  
  57. static struct Library *GetMyBase(void)
  58. {
  59.     return((struct Library *)getreg(REG_A6));
  60. }
  61.  
  62.  
  63. void CloseDriver(void)
  64. {
  65.     if(!havedriver)
  66.         return;
  67.     havedriver = FALSE;
  68.  
  69.     if(mesadriverBase)
  70.         AmigaMesaRTLSetAttrs(
  71.                     AMRTL_GLBase,    NULL,
  72.                     TAG_END);
  73.  
  74.     if(mydriver)
  75.     {
  76.         if(mesadriverBase) CloseLibrary(mesadriverBase);
  77.         mesadriverBase = NULL;
  78.     }
  79.     mydriver = FALSE;
  80. }
  81.  
  82.  
  83. void OpenDriver(char *dname_arg)
  84. {
  85.     char dname[48];
  86.     ULONG dver;
  87.     char str[32];
  88.  
  89.     /* Can only set driver library once (at the moment) */
  90.     if(havedriver)
  91.         return;
  92.  
  93.     dver = 2;
  94.     if(GetVar("AmigaMesaRTL/DriverVersion",str,32,0) != -1)
  95.         dver = atol(str);
  96.  
  97.     if(dname_arg)
  98.         mesadriverBase = OpenLibrary(dname_arg,dver);
  99.     else
  100.     {
  101.         strcpy(dname,"MesaDrivers/amigamesartl");
  102.         if(GetVar("AmigaMesaRTL/Driver",str,32,0) != -1)
  103.         {
  104.             strcpy(dname,"MesaDrivers/");
  105.             strncat(dname,str,32);
  106.         }
  107.  
  108.         mesadriverBase = OpenLibrary(dname,dver);
  109.     }
  110.  
  111.     if(!mesadriverBase)
  112.         return;
  113.  
  114.     havedriver = TRUE;
  115.     mydriver = TRUE;
  116.  
  117.     AmigaMesaRTLSetAttrs(
  118.                 AMRTL_GLBase, GetMyBase(),
  119.                 TAG_END);
  120. }
  121.  
  122.  
  123. void SwitchDriver(struct Library *newdriver)
  124. {
  125.     /* Can only set driver library once (at the moment) */
  126.     if((havedriver && newdriver) || ((!havedriver) && (!newdriver)))
  127.         return;
  128.  
  129.     CloseDriver();
  130.  
  131.     mesadriverBase = newdriver;
  132.  
  133.     if(!mesadriverBase)
  134.         return;
  135.  
  136.     havedriver = TRUE;
  137.  
  138.     AmigaMesaRTLSetAttrs(
  139.                 AMRTL_GLBase, GetMyBase(),
  140.                 TAG_END);
  141. }
  142.  
  143.  
  144. CBMLIB_DESTRUCTOR(mesaDestruct)
  145. {
  146.     CloseDriver();
  147. }
  148.  
  149.  
  150. __asm __saveds GLvisual* APIENTRY mesaCreateVisualA(register __a0 void *vargs)
  151. {
  152.     struct mesaCreateVisualArgs {
  153.         GLboolean rgb_flag;
  154.         GLboolean alpha_flag;
  155.         GLboolean db_flag;
  156.         GLint depth_bits;
  157.         GLint stencil_bits;
  158.         GLint accum_bits;
  159.         GLint index_bits;
  160.         GLfloat red_scale;
  161.         GLfloat green_scale;
  162.         GLfloat blue_scale;
  163.         GLfloat alpha_scale;
  164.         GLint red_bits;
  165.         GLint green_bits;
  166.         GLint blue_bits;
  167.         GLint alpha_bits;
  168.     } *args;
  169.  
  170.     args = (struct mesaCreateVisualArgs *)vargs;
  171.  
  172.     return mesaCreateVisual(args->rgb_flag,
  173.                             args->alpha_flag,
  174.                             args->db_flag,
  175.                             args->depth_bits,
  176.                             args->stencil_bits,
  177.                             args->accum_bits,
  178.                             args->index_bits,
  179.                             args->red_scale,
  180.                             args->green_scale,
  181.                             args->blue_scale,
  182.                             args->alpha_scale,
  183.                             args->red_bits,
  184.                             args->green_bits,
  185.                             args->blue_bits,
  186.                             args->alpha_bits);
  187. }
  188.  
  189.  
  190. __asm __saveds GLvisual* APIENTRY mesaCreateVisual( register __d0 GLboolean rgb_flag,
  191.                                                     register __d1 GLboolean alpha_flag,
  192.                                                     register __d2 GLboolean db_flag,
  193.                                                     register __d3 GLint depth_bits,
  194.                                                     register __d4 GLint stencil_bits,
  195.                                                     register __d5 GLint accum_bits,
  196.                                                     register __d6 GLint index_bits,
  197.                                                     register __fp0 GLfloat red_scale,
  198.                                                     register __fp1 GLfloat green_scale,
  199.                                                     register __fp2 GLfloat blue_scale,
  200.                                                     register __fp3 GLfloat alpha_scale,
  201.                                                     register __d7 GLint red_bits,
  202.                                                     register __a0 GLint green_bits,
  203.                                                     register __a1 GLint blue_bits,
  204.                                                     register __a2 GLint alpha_bits)
  205. {
  206.     return gl_create_visual(rgb_flag,
  207.                             alpha_flag,
  208.                             db_flag,
  209.                             depth_bits,
  210.                             stencil_bits,
  211.                             accum_bits,
  212.                             index_bits,
  213.                             red_scale,
  214.                             green_scale,
  215.                             blue_scale,
  216.                             alpha_scale,
  217.                             red_bits,
  218.                             green_bits,
  219.                             blue_bits,
  220.                             alpha_bits);
  221. }
  222.  
  223.  
  224. __asm __saveds void APIENTRY mesaDestroyVisual( register __a0 GLvisual *vis)
  225. {
  226.     gl_destroy_visual( vis );
  227. }
  228.  
  229.  
  230. __asm __saveds GLcontext* APIENTRY mesaCreateContext( register __a0 GLvisual *vis, register __a1 GLcontext *share, register __a2 void *c )
  231. {
  232.     return gl_create_context( vis,
  233.                               share,
  234.                               c );
  235. }
  236.  
  237.  
  238. __asm __saveds void APIENTRY mesaDestroyContext( register __a0 GLcontext *ctx )
  239. {
  240.     gl_destroy_context( ctx );
  241. }
  242.  
  243.  
  244. __asm __saveds GLframebuffer* APIENTRY mesaCreateFramebuffer( register __a0 GLvisual *vis )
  245. {
  246.     return gl_create_framebuffer( vis );
  247. }
  248.  
  249.  
  250. __asm __saveds void APIENTRY mesaDestroyFramebuffer( register __a0 GLframebuffer *buf )
  251. {
  252.     gl_destroy_framebuffer( buf );
  253. }
  254.  
  255.  
  256. __asm __saveds void APIENTRY mesaMakeCurrent( register __a0 GLcontext *ctx, register __a1 GLframebuffer *buffer )
  257. {
  258.     gl_make_current( ctx, buffer );
  259. }
  260.  
  261.  
  262. __asm __saveds GLcontext* APIENTRY mesaGetCurrentContext( void )
  263. {
  264.     return gl_get_current_context();
  265. }
  266.  
  267.  
  268. __asm __saveds void APIENTRY mesaCopyContext( register __a0 const GLcontext *src, register __a1 GLcontext *dst, register __d0 GLuint mask )
  269. {
  270.     gl_copy_context(src, dst, mask);
  271. }
  272.  
  273.  
  274. __asm __saveds void APIENTRY mesaSetAPITable( register __a0 GLcontext *ctx, register __a1 const struct gl_api_table *api )
  275. {
  276.     gl_set_api_table(ctx, api);
  277. }
  278.  
  279.  
  280. __asm __saveds void APIENTRY mesaProblem( register __a0 const GLcontext *ctx, register __a1 const char *s )
  281. {
  282.     gl_problem( ctx, s );
  283. }
  284.  
  285.  
  286. __asm __saveds void APIENTRY mesaWarning( register __a0 const GLcontext *ctx, register __a1 const char *s )
  287. {
  288.     gl_warning( ctx, s );
  289. }
  290.  
  291.  
  292. __asm __saveds void APIENTRY mesaError( register __a0 const GLcontext *ctx, register __d0 GLenum error, register __a1 const char *s )
  293. {
  294.     gl_error( ctx, error, s );
  295. }
  296.  
  297.  
  298. __asm __saveds GLenum APIENTRY mesaGetError( register __a0 GLcontext *ctx )
  299. {
  300.     return gl_GetError( ctx );
  301. }
  302.  
  303.  
  304. __asm __saveds void APIENTRY mesaUpdateState( register __a0 GLcontext *ctx )
  305. {
  306.     gl_update_state( ctx );
  307. }
  308.  
  309.  
  310. __asm __saveds void APIENTRY mesaViewport( register __a0 GLcontext *ctx, register __d0 GLint x, register __d1 GLint y, register __d2 GLsizei width, register __d3 GLsizei height )
  311. {
  312.     gl_Viewport(ctx,x,y,width,height);
  313. }
  314.  
  315.  
  316. #define CHECK_DRIVER    if(!havedriver) OpenDriver(NULL)
  317.  
  318. __asm __saveds ULONG mesaGetAttr(register __d0 ULONG attr, register __a0 ULONG *data)
  319. {
  320.     switch(attr)
  321.     {
  322.         case MESA_Driver:
  323.             CHECK_DRIVER;
  324.             *((char **)data) = mesadriverBase->lib_IdString;
  325.             break;
  326.         case MESA_DriverVersion:
  327.             CHECK_DRIVER;
  328.             *((ULONG *)data) = mesadriverBase->lib_Version;
  329.             break;
  330.         case MESA_DriverBase:
  331.             CHECK_DRIVER;
  332.             *((struct Library **)data) = mesadriverBase;
  333.             break;
  334.         case MESA_HaveDriver:
  335.             *((BOOL *)data) = havedriver;
  336.             break;
  337.         default:
  338.             return(0);
  339.     }
  340.  
  341.     return(1);
  342. }
  343.  
  344.  
  345. __asm __saveds ULONG mesaSetAttrsA(register __a0 struct TagItem *tags)
  346. {
  347.     struct TagItem *tstate, *tag